package com.mall.service.Impl;

import com.mall.common.Const;
import com.mall.common.ServerResponse;
import com.mall.common.TokenCache;
import com.mall.dao.UserMapper;
import com.mall.pojo.User;
import com.mall.service.IUserService;
import com.mall.util.MD5Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.UUID;

/**
 * Created by xiaoyao on 2017/8/14.
 */
@Service("iUserService")
public class UserServiceImpl implements IUserService{

    @Autowired
    private UserMapper userMapper;

    /**
     * 用户登录
     * @param user
     * @return
     */
    @Override
    public ServerResponse<User> login(User user) {
        //检查用户名是否存在
        int resultCount = userMapper.checkUsername(user.getUsername());
        if(resultCount == 0 ){
            System.out.println("----------------ServiceImpl返回++用户名不存在------------------");
            return ServerResponse.createByErrorMessage("用户名不存在");
        }
        //对密码进行MD5转换
        String md5Password = MD5Util.MD5EncodeUtf8(user.getPassword());
        //检查用户名和密码是否匹配：
        User userCheck = userMapper.selectLogin(user.getUsername(),md5Password);
        if(userCheck == null){
            System.out.println("----------------ServiceImpl返回++密码错误------------------");
            return ServerResponse.createByErrorMessage("密码错误");
        }
        //登录成功，密码处理为null;
        userCheck.setPassword(org.apache.commons.lang3.StringUtils.EMPTY);
        System.out.println("----------------ServiceImpl返回++登录成功------------------");
        return ServerResponse.createBySuccess("登录成功",userCheck);
    }

    /**
     * 数据校验
     * @param type 表示要校验的key
     * @param str  表示要校验的value
     * @return
     * 当key不为空的时候开始校验,否则提示“参数错误”
     * 这里仅仅验证了手机号，邮箱，用户名；
     */
    public ServerResponse<String> checkValid(String type, String str){
        if(org.apache.commons.lang3.StringUtils.isNoneBlank(type)){
            //isNotBlank()的空格与空白看为一样，都为空，返回值为。。。true;
            //开始校验，校验用户名
            if(Const.USERNAME.equals(type)){
                int resultCount = userMapper.checkUsername(str);
                if(resultCount > 0 ){
                    return ServerResponse.createByErrorMessage("用户名已存在");
                }
            }
            //校验手机号
            if(Const.PHONE.equals(type)){
                int resultCount = userMapper.checkPhone(str);
                if(resultCount > 0 ){
                    return ServerResponse.createByErrorMessage("手机号已存在");
                }
            }
            //校验邮箱
            if(Const.EMAIL.equals(type)){
                int resultCount = userMapper.checkEmail(str);
                if(resultCount > 0 ){
                    return ServerResponse.createByErrorMessage("邮箱已存在");
                }
            }
        }else {
            return ServerResponse.createByErrorMessage("参数错误！");
        }
        return ServerResponse.createBySuccessMessage("校验成功！");
    }

    /**
     * 用户注册
     * @param user
     * @return
     * 检查用户名是否存在，如果存在，提示并不允许注册；
     * 同样检查手机号，邮箱；
     * 如果通过检查，则可以注册，把提交的信息添加到数据库中。
     */
    @Override
    public ServerResponse<String> register(User user) {
        ServerResponse<String> validResponse = this.checkValid(Const.USERNAME,user.getUsername());
        if(!validResponse.isSuccess()){
            //如果校验没有通过，则返回validResponse
            return validResponse;
        }
        validResponse = this.checkValid(Const.PHONE,user.getPhone());
        if(!validResponse.isSuccess()){
            return validResponse;
        }
        validResponse = this.checkValid(Const.EMAIL,user.getEmail());
        if(!validResponse.isSuccess()){
            return validResponse;
        }
        //对新注册信息的密码进行MD5加密
        user.setPassword(MD5Util.MD5EncodeUtf8(user.getPassword()));
        int resultCount = userMapper.insert(user);
        if(resultCount == 0){
            return ServerResponse.createByErrorMessage("注册失败");
        }
        return ServerResponse.createBySuccessMessage("注册成功");
    }

    /**
     * 根据用户名获取用户密保问题
     * @param username
     * @return
     * 1、该用户是否存在
     * 2、该用户是否有密保问题
     * 3、若前面两个都正确返回，则开始重置密码
     */
    public ServerResponse<String> checkUserQuestion(String username){
        ServerResponse<String> validResponse = this.checkValid(Const.USERNAME,username);
        if(validResponse.isSuccess()){
            return ServerResponse.createByErrorMessage("用户不存在！");
        }
        String question = userMapper.selectQuestionByUsername(username);
        if(org.apache.commons.lang3.StringUtils.isNoneBlank(question)){
            return ServerResponse.createBySuccess(question);
        }
        return ServerResponse.createByErrorMessage("该用户没有密保问题");
    }
    public ServerResponse<String> checkAnswer(String username,String question,String answer){
        int resultCount = userMapper.checkAnswer(username, question, answer);
        if(resultCount > 0){
            //todo ——Token的学习理解和运用；
            String forgetToken = UUID.randomUUID().toString();
            //将token存储到本地Cache中，以及有效期；
            TokenCache.setKey(TokenCache.TOKEN_PREFIX+username,forgetToken);
            return ServerResponse.createBySuccess(forgetToken);
        }
        return ServerResponse.createByErrorMessage("答案不正确");
    }
    public ServerResponse<String> forgetResetPassword(String username,String passwordNew,String forgetToken) {
        //如果forgetToken为空白的，返回值为true,才执行这里
        if (org.apache.commons.lang3.StringUtils.isBlank(forgetToken)) {
            return ServerResponse.createByErrorMessage("参数错误，Token需要传递！");
        }
        //校验用户名
        ServerResponse<String> validResponse = this.checkValid(Const.USERNAME, username);
        if (validResponse.isSuccess()) {
            return ServerResponse.createByErrorMessage("用户不存在！");
        }
        //获取Token
        String token = TokenCache.getKey(TokenCache.TOKEN_PREFIX+username);
        //校验Cache里的token;
        //如果forgetToken为空白的，返回值为true,才执行这里
        if (org.apache.commons.lang3.StringUtils.isBlank(token)) {
            return ServerResponse.createByErrorMessage("Token无效或者过期！");
        }
        //设置密码
        if (org.apache.commons.lang3.StringUtils.equals(forgetToken,token)) {
            String md5Password = MD5Util.MD5EncodeUtf8(passwordNew);
            int rowCount = userMapper.updatePasswordByUsername(username, md5Password);
            if(rowCount > 0){
                return ServerResponse.createBySuccessMessage("密码修改成功！");
            }
        }else{
            return ServerResponse.createByErrorMessage("Token错误，请重新获取重置密码token!");
        }
        return ServerResponse.createByErrorMessage("修改密码失败！");
    }

    /**
     * 登录状态下修改密码
     * @param user
     * @param passwordOld
     * @param passwordNew
     * @return
     * 1、校验用户名与旧密码是否匹配；
     * 2、更置密码
     * 3、更新用户信息
     */
    public ServerResponse<String> resetPassword(User user,String passwordOld,String passwordNew){
        int resultCount = userMapper.checkPassword(user.getId(),MD5Util.MD5EncodeUtf8(passwordOld));
        if(resultCount == 0){
            return ServerResponse.createByErrorMessage("旧密码错误！");
        }
        //重新设置密码；
        user.setPassword(MD5Util.MD5EncodeUtf8(passwordNew));
        //更新用户信息；
        int updateCount = userMapper.updateByPrimaryKeySelective(user);
        if(updateCount > 0){
            return ServerResponse.createBySuccessMessage("重置密码成功");
        }
        return ServerResponse.createByErrorMessage("重置密码失败");
    }

    /**
     * 获取用户信息
     * @param userId
     * @return
     * 1、通过userId查找用户，
     * 2、密码重置为null;
     * 3、返回用户信息
     */
    public ServerResponse<User> getInformation(Integer userId){
        User user = userMapper.selectByPrimaryKey(userId);
        if(user == null){
            return ServerResponse.createByErrorMessage("找不到当前用户");
        }
        user.setPassword(org.apache.commons.lang3.StringUtils.EMPTY);
        return ServerResponse.createBySuccess(user);
    }

    /**
     * 修改用户信息
     * @param user
     * @return
     * 1、校验要修改的数据是否合法；
     * 2、添加更改
     */
    public ServerResponse<User> updateInformation(User user){
        //校验username,phone,email是否被别人占用；
        int resultCount = userMapper.checkUsernameByUserId(user.getId(),user.getUsername());
        if(resultCount > 0){
            return ServerResponse.createByErrorMessage("该用户名已其他人被占用！");
        }
        resultCount = userMapper.checkPhoneByUserId(user.getId(),user.getPhone());
        if(resultCount > 0){
            return ServerResponse.createByErrorMessage("该手机号已其他人被占用");
        }
        resultCount = userMapper.checkEmailByUserId(user.getId(),user.getEmail());
        if(resultCount > 0){
            return ServerResponse.createByErrorMessage("该邮箱已其他人被占用");
        }
        User updateUser = new User();
        updateUser.setId(user.getId());
        updateUser.setUsername(user.getUsername());
        //用户角色 和 密码 就不给修改了；
//        updateUser.setPassword(user.getPassword());
        updateUser.setPhone(user.getPhone());
        updateUser.setPhoto(user.getPhoto());
        updateUser.setWallet(user.getWallet());
        updateUser.setPoint(user.getPoint());
        updateUser.setEmail(user.getEmail());
        updateUser.setQuestion(user.getQuestion());
        updateUser.setAnswer(user.getAnswer());

        int updateCount = userMapper.updateByPrimaryKeySelective(updateUser);
        if(updateCount > 0){
            return ServerResponse.createBySuccess("修改成功！",updateUser);
        }
        return ServerResponse.createByErrorMessage("修改用户信息失败了");
    }

    /**
     * 校验管理员身份
     * @param user
     * @return
     */
    public ServerResponse checkAdminRole(User user){
        if(user != null && user.getRole().intValue() == Const.Role.ROLE_ADMIN){
            return ServerResponse.createBySuccess();
        }
        return ServerResponse.createByError();
    }

}
